var rosObj = null

var rosUrl = ""

var topic = {
  holderControl: null,
  carControl: null,
  oneButtonBack: null,
  controlDoor: null,
  taskClear: null,
  roadPlan: null,
  pointStatus: null,
  urgencyTask: null,
  taskControlStatus: null,
  dbTableUpdate: null,
  controlModel: null,
  chargeHouseAndBackPoint: null,
  stopReceiveLaser: null,
  holderControlServices: null,
}

// 心跳状态 1 存在 0 不存在
var heartStatus = 0;

exports.install = function (Vue, options) {
  Vue.prototype.controlRosInit = function (data) {
    console.log("ros init");
    rosObj = new ROSLIB.Ros();
    monitorsHeart();
    return rosObj;
  }

  Vue.prototype.controlRosConnect = function (data) {
    if (data && data.url) {
      console.log("ros connect");
      rosObj.connect(data.url);
      rosUrl = data.url
      return true;
    } else {
      return false;
    }
  }

  Vue.prototype.controlRosClose = function (data) {
    console.log("ros close");
    rosObj.close();
    return true;
  }

  Vue.prototype.controlRosConnectStatus = function (data) {
    console.log("ros connected");
    return rosObj;
  }

  Vue.prototype.controlRosOnConnection = function (data) {
    rosObj.on("connection", function () {
      console.log("ros connection");
      rosUnsubscribes()
      rosSubscribes()
    });
    return true;
  }

  Vue.prototype.controlRosOnClose = function (data) {
    rosObj.on("close", function () {
      console.log("ros close");
    });
    return true;
  }

  Vue.prototype.controlRosOnError = function (data) {
    rosObj.on("error", function (error) {
      console.log("ros error");
    });
    return true;
  }


  /**
   *   发送数据库更新表
   *
   *   @param {*} parameter 发送的参数
   */
  Vue.prototype.dbTableUpdatePub = function (parameter) {
    if (
      topic.dbTableUpdate
    ) {
      var twist = new ROSLIB.Message(parameter);
      topic.dbTableUpdate.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
   *   发送云台控制				
   *				
   *   @param {*} parameter 发送的参数				
   */
  Vue.prototype.holderControlPub = function (parameter) {
    if (topic.holderControl) {
      var twist = new ROSLIB.Message(parameter);
      topic.holderControl.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
   *   发送上位机控制				
   *				
   *   @param {*} parameter 发送的参数				
   */
  Vue.prototype.carControlPub = function (parameter) {
    if (topic.carControl) {
      var twist = new ROSLIB.Message(parameter);
      topic.carControl.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
  *   发送控制模式切换		
  *				
  *   @param {*} parameter 发送的参数				
  */
  Vue.prototype.controlModelPub = function (parameter) {
    if (topic.controlModel) {
      var twist = new ROSLIB.Message(parameter);
      topic.controlModel.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
   *   发送一键返航				
   *				
   *   @param {*} parameter 发送的参数				
   */
  Vue.prototype.oneButtonBackPub = function (parameter) {
    if (topic.oneButtonBack) {
      var twist = new ROSLIB.Message(parameter);
      topic.oneButtonBack.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
   *   发送巡检点位状态				
   *				
   *   @param {*} parameter 发送的参数				
   */
  Vue.prototype.pointStatusPub = function (parameter) {
    if (topic.pointStatus) {
      var twist = new ROSLIB.Message(parameter);
      topic.pointStatus.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
   *   发送执行任务				
   *				
   *   @param {*} parameter 发送的参数				
   */
  Vue.prototype.urgencyTaskPub = function (parameter) {
    if (topic.urgencyTask) {
      var twist = new ROSLIB.Message(parameter);
      topic.urgencyTask.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
   *   发送任务控制状态				
   *				
   *   @param {*} parameter 发送的参数				
   */
  Vue.prototype.taskControlStatusPub = function (parameter) {
    if (topic.taskControlStatus) {
      var twist = new ROSLIB.Message(parameter);
      topic.taskControlStatus.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
   *   发送数据库更新表名			
   *				
   *   @param {*} parameter 发送的参数				
   */
  Vue.prototype.dbTableUpdatePub = function (parameter) {
    if (topic.dbTableUpdate) {
      var twist = new ROSLIB.Message(parameter);
      topic.dbTableUpdate.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
   *   发送狗窝 back 坐标			
   *				
   *   @param {*} parameter 发送的参数		
   */
  Vue.prototype.chargeHouseAndBackPointPub = function (parameter) {
    if (topic.chargeHouseAndBackPoint) {
      var twist = new ROSLIB.Message(parameter);
      topic.chargeHouseAndBackPoint.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
   *   发送定位中的开关控制		
   *				
   *   @param {*} parameter 发送的参数		
   */
  Vue.prototype.stopReceiveLaserPub = function (parameter) {
    if (topic.stopReceiveLaser) {
      var twist = new ROSLIB.Message(parameter);
      console.log("发送定位中的开关控制	:", twist)
      topic.stopReceiveLaser.publish(twist);
      return 0
    } else {
      return -1;
    }
  }

  /**				
   *   任务管理服务(service)				
   *				
   *   @param {*} parameter 发送的参数	
   *   @param {*} callback	服务回到函数
   */
  Vue.prototype.taskClearCallSeavice = function (parameter, callback) {
    if (topic.taskClear) {
      var require = new ROSLIB.ServiceRequest(parameter);
      topic.taskClear.callService(require, callback)
    }
  }

  /**				
   *   路径规划服务(service)				
   *				
   *   @param {*} parameter 发送的参数
   *   @param {*} callback	服务回到函数		
   */
  Vue.prototype.roadPlanCallSeavice = function (parameter, callback) {
    if (topic.roadPlan) {
      var require = new ROSLIB.ServiceRequest(parameter);
      topic.roadPlan.callService(require, callback)
    }
  }

  /**				
   *   门控制服务(service)				
   *				
   *   @param {*} parameter 发送的参数
   *   @param {*} callback	服务回到函数		
   */
  Vue.prototype.controlDoorCallSeavice = function (parameter, callback) {
    if (topic.controlDoor) {
      var require = new ROSLIB.ServiceRequest(parameter);
      topic.controlDoor.callService(require, callback)
    }
  }

  /**				
   *   云台控制服务(service)				
   *				
   *   @param {*} parameter 发送的参数
   *   @param {*} callback	服务回到函数		
   */
  Vue.prototype.holderControlCallServices = function (parameter, callback) {
    if (topic.holderControlServices) {
      var require = new ROSLIB.ServiceRequest(parameter);
      topic.holderControlServices.callService(require, callback)
    }
  }
};

/**
 *  订阅所有
 *
 */
function rosSubscribes() {
  rosRoadPlanSubscribe();
  rosHolderControlSubscribe();
  rosHolderControlServicesSubscribe();
  rosCarControlSubscribe();
  rosControlModelSubscribe();
  rosOneButtonBackSubscribe();
  rosTaskClearSubscribe();
  rosPointStatusSubscribe();
  rosUrgencyTaskSubscribe();
  rosTaskControlStatusSubscribe();
  rosDBTableUpdateSubscribe();
  rosChargeHouseAndBackPointSubscribe();
  stopReceiveLaserSubscribe();
}

/**
 *  取消订阅所有
 *
 */
function rosUnsubscribes() {
}


/**				
 *   云台控制声明		
 *	 只有发送，所以没有订阅和取消订阅
 */
function rosHolderControlSubscribe() {
  topic.holderControl = new ROSLIB.Topic({
    ros: rosObj,
    name: "/yunTai_ctrl",
    messageType: "yidamsg/yuntai_control"
  });
}


/**				
 *   云台控制服务声明			
 *	 
 */
function rosHolderControlServicesSubscribe() {
  topic.holderControlServices = new ROSLIB.Service({
    ros: rosObj,
    name: "/cloudplatform_control",
    serviceType: "cloud_platform/CloudPlatControl"
  });
}


/**				
 *   上位机控制声明				
 *	 只有发送，所以没有订阅和取消订阅
 */
function rosCarControlSubscribe() {
  topic.carControl = new ROSLIB.Topic({
    ros: rosObj,
    name: "/yida/robot/motor_control2",
    messageType: "yidamsg/motor_control"
  });
}


/**				
 *   控制模式切换声明和订阅				
 *				
 */
function rosControlModelSubscribe() {
  topic.controlModel = new ROSLIB.Topic({
    ros: rosObj,
    name: "/yida/robot/control_mode",
    messageType: "std_msgs/Int16"
  });
}


/**				
 *   一键返航声明
 *	 只有发送，所以没有订阅和取消订阅
 */
function rosOneButtonBackSubscribe() {
  topic.oneButtonBack = new ROSLIB.Topic({
    ros: rosObj,
    name: "/yida/robot/oneButtonBack",
    messageType: "yidamsg/onebutton"
  });
}


/**				
 *   门控制声明和订阅				
 *	 暂时没有使用
 */
function rosControlDoorSubscribe() {
  topic.controlDoor = new ROSLIB.Service({
    ros: rosObj,
    name: "/control_door",
    serviceType: "Yidamsg/ControlDoor"
  });
}


/**				
 *   任务管理声明	
 *	 只有发送，所以没有订阅和取消订阅
 */
function rosTaskClearSubscribe() {
  topic.taskClear = new ROSLIB.Service({
    ros: rosObj,
    name: "/taskclear",
    serviceType: "yidamsg/TaskControl"
  });
}


/**				
 *   路径规划声明和订阅				
 *				
 */
function rosRoadPlanSubscribe() {
  topic.roadPlan = new ROSLIB.Service({
    ros: rosObj,
    name: "/task",
    serviceType: "yidamsg/RoadPlan"
  });
}


/**				
 *   巡检点位状态声明
 *   只有发送，所以没有订阅和取消订阅
 */
function rosPointStatusSubscribe() {
  topic.pointStatus = new ROSLIB.Topic({
    ros: rosObj,
    name: "/point_status",
    messageType: "yidamsg/point_status"
  });
}


/**				
 *   执行任务声明		
 *   只有发送，所以没有订阅和取消订阅
 */
function rosUrgencyTaskSubscribe() {
  topic.urgencyTask = new ROSLIB.Topic({
    ros: rosObj,
    name: "/urgency_task",
    messageType: "yidamsg/UrgencyTask"
  });
}


/**				
 *   任务控制状态声明		
 *   只有发送，所以没有订阅和取消订阅
 */
function rosTaskControlStatusSubscribe() {
  topic.taskControlStatus = new ROSLIB.Topic({
    ros: rosObj,
    name: "/task_control_status",
    messageType: "yidamsg/TaskControlStatus"
  });
}


/**
 *   数据库更新表名声明
 *   只有发送，所以没有订阅和取消订阅
 */
function rosDBTableUpdateSubscribe() {
  topic.dbTableUpdate = new ROSLIB.Topic({
    ros: rosObj,
    name: "/db_table_update",
    messageType: "yidamsg/DBTableUpdate"
  });
}


/**				
 *   装载点 back 坐标声明			
 *   只有发送，所以没有订阅和取消订阅
 */
function rosChargeHouseAndBackPointSubscribe() {
  topic.chargeHouseAndBackPoint = new ROSLIB.Topic({
    ros: rosObj,
    name: "/set_start_back_point",
    messageType: "yidamsg/start_back_point"
  });
}


/**				
 *   定位中的开关控制		
 *   只有发送，所以没有订阅和取消订阅
 */
function stopReceiveLaserSubscribe() {
  topic.stopReceiveLaser = new ROSLIB.Topic({
    ros: rosObj,
    name: "/stop_receive_laser",
    messageType: "std_msgs/Bool"
  });
}


function monitorsHeart() {
  setInterval(() => {
    if (heartStatus == 1) {
      heartStatus = 0;
    } else {
      console.log("ros heartStatus", heartStatus)
      rosObj.connect(rosUrl);
    }
  }, 3000);
}

